<!DOCTYPE html>
<html lang="zh-CN">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>面向对象编程 - C++学习入门</title>
    <!-- 引入Google Fonts -->
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <link
        href="https://fonts.googleapis.com/css2?family=Fira+Code:wght@400;500;600&family=Inter:wght@300;400;500;600;700&family=Montserrat:wght@400;500;600;700;800&display=swap"
        rel="stylesheet">
    <link rel="stylesheet" href="../css/style2.css">
    <!-- 引入Font Awesome图标库 -->
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">

</head>

<body>
    <header>
        <nav>
            <!-- 移动端主题切换按钮 -->
            <button id="mobile-theme-toggle" class="mobile-theme-toggle-btn">
                <i class="fas fa-sun"></i>
                <i class="fas fa-moon"></i>
            </button>
            <div class="logo">C++学习入门</div>
            <ul class="nav-links">
                <li><a href="../index.html">首页</a></li>
                <li><a href="basics.html">基础语法</a></li>
                <li><a href="oop.html" class="active">面向对象</a></li>
                <li><a href="advanced.html">高级特性</a></li>
                <li><a href="effective.html">Effective C++</a></li>
                <li><a href="stl.html">STL源码剖析</a></li>
                <li><a href="quiz.html">题库</a></li>
                <li><a href="achievements.html">成就系统</a></li>
                <li><a href="../forum.html">论坛</a></li>
                <li class="dropdown">
                    <a href="#" class="dropdown-toggle">账户 <i class="fas fa-chevron-down"></i></a>
                    <ul class="dropdown-menu">
                        <li><a href="#login-modal">登录</a></li>
                        <li><a href="#register-modal">注册</a></li>
                    </ul>
                </li>
                <li><a href="../about.html">关于我们</a></li>
                <li><button id="theme-toggle" class="theme-toggle-btn">
                        <i class="fas fa-sun"></i>
                        <i class="fas fa-moon"></i>
                    </button></li>
            </ul>
            <div class="burger">
                <div class="line1"></div>
                <div class="line2"></div>
                <div class="line3"></div>
            </div>
        </nav>
    </header>

    <main class="tutorial-container">
        <div class="tutorial-sidebar">
            <h3>目录</h3>
            <ul class="tutorial-nav">
                <li><a href="#intro">OOP核心概念</a></li>
                <li><a href="#classes-objects">类与对象</a></li>
                <li><a href="#special-methods">特殊成员函数</a></li>
                <li><a href="#encapsulation">封装与访问控制</a></li>
                <li><a href="#inheritance">继承</a></li>
                <li><a href="#polymorphism">多态</a></li>
                <li><a href="#abstract-classes">抽象类与接口</a></li>
                <li><a href="#friends">友元</a></li>
                <li><a href="#static-members">静态成员</a></li>
                <li><a href="#operator-overloading">运算符重载</a></li>
                <li><a href="#templates">模板与泛型</a></li>
                <li><a href="#best-practices">最佳实践</a></li>
            </ul>
        </div>

        <div class="tutorial-content">
            <h1>C++面向对象编程深入解析</h1>
            <p class="intro">面向对象编程(Object-Oriented Programming,
                OOP)是一种基于对象概念的编程范式，它通过封装、继承和多态等机制来组织代码。C++作为一门多范式语言，对OOP提供了全面而强大的支持。本文将从资深开发者的角度深入探讨C++ OOP的各个方面。</p>

            <section id="intro" class="section">
                <h2>OOP核心概念</h2>
                <p>面向对象编程基于四个核心原则：</p>
                <ol>
                    <li><strong>抽象</strong>：简化复杂现实的方法，建模时只关注相关细节</li>
                    <li><strong>封装</strong>：将数据和行为捆绑在一起，并控制对其的访问</li>
                    <li><strong>继承</strong>：基于现有类创建新类的机制，实现代码复用</li>
                    <li><strong>多态</strong>：同一接口可以用于不同的底层形式，提高灵活性</li>
                </ol>

                <div class="advanced">
                    <h4>深入理解</h4>
                    <p>在C++中，OOP不仅仅是语法特性，更是一种设计和组织代码的方式。良好的OOP设计能够提高代码的可维护性、可扩展性和可重用性。与C语言的过程式编程相比，OOP更适合大型复杂系统的开发。</p>
                </div>
            </section>

            <section id="classes-objects" class="section">
                <h2>类与对象</h2>
                <p>类是面向对象编程的核心概念，它是创建对象的蓝图或模板。对象是类的实例。</p>

                <h3>类的定义</h3>
                <p>类定义包括数据成员（属性）和成员函数（方法）：</p>
                <div class="code-block">
                    <pre><code>// 类声明
class Rectangle {
private:    // 访问修饰符
    double width;    // 数据成员
    double height;

public:     // 访问修饰符
    // 成员函数声明
    void setDimensions(double w, double h);
    double getArea() const;  // const成员函数，不修改对象状态
    double getPerimeter() const;
    
    // 内联成员函数
    double getWidth() const { return width; }
    double getHeight() const { return height; }
};</code></pre>
                </div>

                <h3>类与结构体的区别</h3>
                <div class="comparison">
                    <div>
                        <h4>类 (class)</h4>
                        <ul>
                            <li>默认成员访问权限为private</li>
                            <li>用于表示具有复杂行为的对象</li>
                            <li>强调封装和数据隐藏</li>
                            <li>通常包含成员函数</li>
                        </ul>
                    </div>
                    <div>
                        <h4>结构体 (struct)</h4>
                        <ul>
                            <li>默认成员访问权限为public</li>
                            <li>主要用于数据聚合</li>
                            <li>在C++中与类的唯一区别是默认访问权限</li>
                            <li>常用于简单数据容器</li>
                        </ul>
                    </div>
                </div>

                <div class="note">
                    <p>注意：在C++中，struct和class的唯一区别是默认访问权限。struct默认是public，class默认是private。除此之外，它们的功能完全相同。</p>
                </div>

                <h3>成员函数定义</h3>
                <div class="code-block">
                    <pre><code>// 类外定义成员函数，使用作用域解析运算符::
void Rectangle::setDimensions(double w, double h) {
    // 数据验证
    if (w <= 0 || h <= 0) {
        throw std::invalid_argument("尺寸必须为正数");
    }
    width = w;
    height = h;
}

double Rectangle::getArea() const {
    return width * height;
}

double Rectangle::getPerimeter() const {
    return 2 * (width + height);
}</code></pre>
                </div>

                <h3>创建和使用对象</h3>
                <div class="code-block">
                    <pre><code>int main() {
    // 栈上创建对象
    Rectangle rect1;
    rect1.setDimensions(5.0, 3.0);
    
    // 堆上创建对象
    Rectangle* rect2 = new Rectangle();
    rect2->setDimensions(4.0, 6.0);
    
    // 使用对象
    std::cout << "矩形1面积: " << rect1.getArea() << std::endl;
    std::cout << "矩形2周长: " << rect2->getPerimeter() << std::endl;
    
    // 释放堆上对象
    delete rect2;
    
    return 0;
}</code></pre>
                </div>
            </section>

            <section id="special-methods" class="section">
                <h2>特殊成员函数</h2>
                <p>C++类有六个特殊成员函数，编译器可以自动生成它们：</p>
                <ol>
                    <li>默认构造函数</li>
                    <li>析构函数</li>
                    <li>拷贝构造函数</li>
                    <li>拷贝赋值运算符</li>
                    <li>移动构造函数 (C++11)</li>
                    <li>移动赋值运算符 (C++11)</li>
                </ol>

                <h3>构造函数与析构函数</h3>
                <div class="code-block">
                    <pre><code>class Student {
private:
    std::string name;
    int age;
    double* grades;  // 动态数组
    int gradeCount;

public:
    // 默认构造函数
    Student() : name("未知"), age(0), grades(nullptr), gradeCount(0) {}
    
    // 参数化构造函数
    Student(std::string n, int a) : name(n), age(a), grades(nullptr), gradeCount(0) {}
    
    // 拷贝构造函数
    Student(const Student &other) : name(other.name), age(other.age), gradeCount(other.gradeCount) {
        // 深拷贝动态数组
        if (other.grades) {
            grades = new double[gradeCount];
            for (int i = 0; i < gradeCount; i++) {
                grades[i] = other.grades[i];
            }
        } else {
            grades = nullptr;
        }
    }
    
    // 拷贝赋值运算符
    Student& operator=(const Student &other) {
        if (this != &other) {  // 防止自赋值
            // 释放现有资源
            delete[] grades;
            
            // 复制新资源
            name = other.name;
            age = other.age;
            gradeCount = other.gradeCount;
            
            if (other.grades) {
                grades = new double[gradeCount];
                for (int i = 0; i < gradeCount; i++) {
                    grades[i] = other.grades[i];
                }
            } else {
                grades = nullptr;
            }
        }
        return *this;
    }
    
    // 移动构造函数 (C++11)
    Student(Student &&other) noexcept : name(std::move(other.name)), age(other.age), 
                                        grades(other.grades), gradeCount(other.gradeCount) {
        // 将源对象置于有效但可析构状态
        other.grades = nullptr;
        other.gradeCount = 0;
    }
    
    // 移动赋值运算符 (C++11)
    Student& operator=(Student &&other) noexcept {
        if (this != &other) {
            // 释放现有资源
            delete[] grades;
            
            // 移动资源
            name = std::move(other.name);
            age = other.age;
            grades = other.grades;
            gradeCount = other.gradeCount;
            
            // 将源对象置于有效但可析构状态
            other.grades = nullptr;
            other.gradeCount = 0;
        }
        return *this;
    }
    
    // 析构函数
    ~Student() {
        delete[] grades;  // 释放动态分配的内存
    }
};</code></pre>
                </div>

                <div class="advanced">
                    <h4>Rule of Three/Five/Zero</h4>
                    <ul>
                        <li><strong>Rule of Three</strong>：如果一个类需要自定义析构函数、拷贝构造函数或拷贝赋值运算符，那么它可能需要所有这三个</li>
                        <li><strong>Rule of Five</strong>：由于C++11引入了移动语义，现在还需要考虑移动构造函数和移动赋值运算符</li>
                        <li><strong>Rule of Zero</strong>：理想情况下，类不应自定义这些特殊成员函数，而应依赖智能指针等资源管理类</li>
                    </ul>
                </div>
            </section>

            <section id="encapsulation" class="section">
                <h2>封装与访问控制</h2>
                <p>封装是OOP的基本原则之一，它将数据和行为捆绑在一起，并控制对其的访问。</p>

                <h3>访问修饰符</h3>
                <table>
                    <tr>
                        <th>修饰符</th>
                        <th>类内访问</th>
                        <th>派生类访问</th>
                        <th>外部访问</th>
                    </tr>
                    <tr>
                        <td><code>private</code></td>
                        <td>是</td>
                        <td>否</td>
                        <td>否</td>
                    </tr>
                    <tr>
                        <td><code>protected</code></td>
                        <td>是</td>
                        <td>是</td>
                        <td>否</td>
                    </tr>
                    <tr>
                        <td><code>public</code></td>
                        <td>是</td>
                        <td>是</td>
                        <td>是</td>
                    </tr>
                </table>

                <h3>封装示例</h3>
                <div class="code-block">
                    <pre><code>class BankAccount {
private:
    std::string accountNumber;
    double balance;
    std::vector&lt;Transaction&gt; transactionHistory;

    // 私有方法，辅助函数
    void logTransaction(const Transaction& t) {
        transactionHistory.push_back(t);
    }

public:
    BankAccount(std::string accNum, double initialBalance = 0.0) 
        : accountNumber(accNum), balance(initialBalance) {}
    
    void deposit(double amount) {
        if (amount <= 0) {
            throw std::invalid_argument("存款金额必须为正数");
        }
        balance += amount;
        logTransaction(Transaction("DEPOSIT", amount));
    }
    
    bool withdraw(double amount) {
        if (amount <= 0) {
            throw std::invalid_argument("取款金额必须为正数");
        }
        if (balance >= amount) {
            balance -= amount;
            logTransaction(Transaction("WITHDRAW", amount));
            return true;
        }
        return false;
    }
    
    double getBalance() const {
        return balance;
    }
    
    std::string getAccountNumber() const {
        return accountNumber;
    }
    
    // 只提供const版本的交易历史访问
    const std::vector&lt;Transaction&gt;& getTransactionHistory() const {
        return transactionHistory;
    }
};</code></pre>
                </div>

                <div class="note">
                    <p>良好的封装实践：将数据成员设为private，通过public方法提供受控的访问。避免返回内部数据的非const引用或指针，以防止外部代码意外修改内部状态。</p>
                </div>
            </section>

            <section id="inheritance" class="section">
                <h2>继承</h2>
                <p>继承允许我们基于现有类创建新类，新类继承了现有类的特性和行为，并可以添加新的功能。</p>

                <h3>继承类型</h3>
                <table>
                    <tr>
                        <th>继承方式</th>
                        <th>基类public成员</th>
                        <th>基类protected成员</th>
                        <th>基类private成员</th>
                    </tr>
                    <tr>
                        <td><code>public</code></td>
                        <td>派生类public成员</td>
                        <td>派生类protected成员</td>
                        <td>不可访问</td>
                    </tr>
                    <tr>
                        <td><code>protected</code></td>
                        <td>派生类protected成员</td>
                        <td>派生类protected成员</td>
                        <td>不可访问</td>
                    </tr>
                    <tr>
                        <td><code>private</code></td>
                        <td>派生类private成员</td>
                        <td>派生类private成员</td>
                        <td>不可访问</td>
                    </tr>
                </table>

                <h3>继承示例</h3>
                <div class="code-block">
                    <pre><code>// 基类
class Shape {
protected:
    std::string color;
    Point center;

public:
    Shape(std::string c, Point cntr) : color(c), center(cntr) {}
    
    virtual ~Shape() {}  // 虚析构函数，确保正确析构派生类对象
    
    virtual double getArea() const = 0;  // 纯虚函数，使Shape成为抽象类
    
    virtual void draw() const {
        std::cout << "绘制形状，颜色: " << color << std::endl;
    }
    
    void move(const Point& newCenter) {
        center = newCenter;
    }
    
    std::string getColor() const {
        return color;
    }
    
    void setColor(std::string c) {
        color = c;
    }
};

// 派生类 - 圆形
class Circle : public Shape {
private:
    double radius;

public:
    Circle(std::string c, Point cntr, double r) 
        : Shape(c, cntr), radius(r) {}
    
    double getArea() const override {
        return 3.14159 * radius * radius;
    }
    
    void draw() const override {
        std::cout << "绘制圆形，颜色: " << color 
                  << ", 半径: " << radius << std::endl;
    }
    
    double getRadius() const {
        return radius;
    }
    
    void setRadius(double r) {
        if (r <= 0) {
            throw std::invalid_argument("半径必须为正数");
        }
        radius = r;
    }
};

// 派生类 - 矩形
class Rectangle : public Shape {
private:
    double width;
    double height;

public:
    Rectangle(std::string c, Point cntr, double w, double h) 
        : Shape(c, cntr), width(w), height(h) {}
    
    double getArea() const override {
        return width * height;
    }
    
    void draw() const override {
        std::cout << "绘制矩形，颜色: " << color 
                  << ", 宽度: " << width 
                  << ", 高度: " << height << std::endl;
    }
    
    double getWidth() const {
        return width;
    }
    
    double getHeight() const {
        return height;
    }
    
    void setDimensions(double w, double h) {
        if (w <= 0 || h <= 0) {
            throw std::invalid_argument("尺寸必须为正数");
        }
        width = w;
        height = h;
    }
};</code></pre>
                </div>

                <div class="advanced">
                    <h4>继承中的构造函数和析构函数</h4>
                    <p>派生类构造函数调用顺序：</p>
                    <ol>
                        <li>基类构造函数</li>
                        <li>成员对象构造函数（按声明顺序）</li>
                        <li>派生类构造函数体</li>
                    </ol>
                    <p>析构函数调用顺序相反：</p>
                    <ol>
                        <li>派生类析构函数体</li>
                        <li>成员对象析构函数（按声明逆序）</li>
                        <li>基类析构函数</li>
                    </ol>
                </div>
            </section>

            <section id="polymorphism" class="section">
                <h2>多态</h2>
                <p>多态允许使用同一接口处理不同类型的对象，是面向对象编程的核心概念之一。</p>

                <h3>虚函数与动态绑定</h3>
                <div class="code-block">
                    <pre><code>class Animal {
public:
    virtual void makeSound() const {
        std::cout << "动物发出声音" << std::endl;
    }
    
    virtual ~Animal() {}  // 虚析构函数，确保正确析构派生类对象
};

class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "汪汪!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "喵喵!" << std::endl;
    }
};

// 使用多态
void animalSounds(const Animal* animals[], int count) {
    for (int i = 0; i < count; i++) {
        animals[i]->makeSound();  // 动态绑定，根据实际对象类型调用相应函数
    }
}

int main() {
    Dog dog;
    Cat cat;
    
    Animal* animals[] = {&dog, &cat};
    animalSounds(animals, 2);
    
    return 0;
}</code></pre>
                </div>

                <h3>override和final关键字 (C++11)</h3>
                <div class="code-block">
                    <pre><code>class Base {
public:
    virtual void func() const;
    virtual void finalFunc() const;
};

class Derived : public Base {
public:
    void func() const override;  // 明确表示重写基类虚函数
    void finalFunc() const final;  // 禁止进一步重写
};

class FurtherDerived : public Derived {
public:
    void func() const override;  // 可以重写
    // void finalFunc() const;  // 错误！不能重写final函数
};</code></pre>
                </div>

                <div class="advanced">
                    <h4>虚函数表(vtable)机制</h4>
                    <p>C++通过虚函数表实现多态：</p>
                    <ol>
                        <li>每个包含虚函数的类都有一个虚函数表</li>
                        <li>虚函数表存储指向该类虚函数的指针</li>
                        <li>每个对象包含一个指向虚函数表的指针(vptr)</li>
                        <li>调用虚函数时，通过vptr找到vtable，再找到正确的函数地址</li>
                    </ol>
                    <p>这种机制虽然增加了少量开销，但提供了强大的多态能力。</p>
                </div>
            </section>

            <section id="abstract-classes" class="section">
                <h2>抽象类与接口</h2>
                <p>抽象类是包含至少一个纯虚函数的类，不能实例化。接口是一种特殊的抽象类，只包含纯虚函数。</p>

                <h3>纯虚函数与抽象类</h3>
                <div class="code-block">
                    <pre><code>// 抽象类
class Shape {
public:
    virtual double getArea() const = 0;  // 纯虚函数
    virtual void draw() const = 0;       // 纯虚函数
    
    virtual ~Shape() {}  // 虚析构函数
};

// 接口类 - 只包含纯虚函数和虚析构函数
class Drawable {
public:
    virtual void draw() const = 0;
    virtual ~Drawable() {}
};

class Printable {
public:
    virtual void print() const = 0;
    virtual ~Printable() {}
};

// 实现多个接口
class Report : public Drawable, public Printable {
private:
    std::string title;
    std::string content;

public:
    Report(std::string t, std::string c) : title(t), content(c) {}
    
    void draw() const override {
        std::cout << "绘制报告: " << title << std::endl;
    }
    
    void print() const override {
        std::cout << "打印报告: " << title << std::endl;
        std::cout << "内容: " << content << std::endl;
    }
};</code></pre>
                </div>
            </section>

            <section id="friends" class="section">
                <h2>友元</h2>
                <p>友元函数和友元类可以访问类的私有和保护成员，打破了封装性，但有时是必要的。</p>

                <h3>友元函数</h3>
                <div class="code-block">
                    <pre><code>class Box {
private:
    double width;

public:
    Box(double w) : width(w) {}
    
    // 声明友元函数
    friend void printWidth(const Box &box);
    friend Box operator+(const Box &a, const Box &b);
};

// 定义友元函数
void printWidth(const Box &box) {
    // 可以直接访问私有成员
    std::cout << "盒子宽度: " << box.width << std::endl;
}

Box operator+(const Box &a, const Box &b) {
    return Box(a.width + b.width);
}</code></pre>
                </div>

                <h3>友元类</h3>
                <div class="code-block">
                    <pre><code>class Storage {
private:
    int data[10];

public:
    Storage() {
        for (int i = 0; i < 10; i++) {
            data[i] = i;
        }
    }
    
    // 声明友元类
    friend class Display;
};

class Display {
public:
    void show(const Storage &storage) {
        // 可以直接访问Storage的私有成员
        for (int i = 0; i < 10; i++) {
            std::cout << storage.data[i] << " ";
        }
        std::cout << std::endl;
    }
};</code></pre>
                </div>

                <div class="warning">
                    <p>注意：友元关系破坏了封装性，应谨慎使用。只有在确实需要访问类的内部实现细节，且无法通过公共接口实现时，才应考虑使用友元。</p>
                </div>
            </section>

            <section id="static-members" class="section">
                <h2>静态成员</h2>
                <p>静态成员属于类而不是对象，所有对象共享同一份静态成员。</p>

                <h3>静态数据成员和静态成员函数</h3>
                <div class="code-block">
                    <pre><code>class Counter {
private:
    static int count;  // 静态数据成员声明

public:
    Counter() {
        count++;  // 每创建一个对象，计数增加
    }
    
    ~Counter() {
        count--;  // 每销毁一个对象，计数减少
    }
    
    // 静态成员函数
    static int getCount() {
        return count;
    }
    
    // 静态常量成员
    static const int MAX_COUNT = 100;
};

// 静态数据成员定义和初始化
int Counter::count = 0;</code></pre>
                </div>

                <h3>使用静态成员</h3>
                <div class="code-block">
                    <pre><code>int main() {
    std::cout << "初始计数: " << Counter::getCount() << std::endl;
    std::cout << "最大计数: " << Counter::MAX_COUNT << std::endl;
    
    {
        Counter c1;
        std::cout << "创建1个对象后计数: " << Counter::getCount() << std::endl;
        
        Counter c2;
        std::cout << "创建2个对象后计数: " << Counter::getCount() << std::endl;
    }
    
    std::cout << "所有对象销毁后计数: " << Counter::getCount() << std::endl;
    
    return 0;
}</code></pre>
                </div>
            </section>

            <section id="operator-overloading" class="section">
                <h2>运算符重载</h2>
                <p>C++允许重定义大多数内置运算符，使它们能够用于用户定义的类型。</p>

                <h3>重载算术运算符</h3>
                <div class="code-block">
                    <pre><code>class Complex {
private:
    double real;
    double imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
    
    // 重载+运算符（成员函数版本）
    Complex operator+(const Complex &other) const {
        return Complex(real + other.real, imag + other.imag);
    }
    
    // 重载-运算符（成员函数版本）
    Complex operator-(const Complex &other) const {
        return Complex(real - other.real, imag - other.imag);
    }
    
    // 重载+=运算符
    Complex& operator+=(const Complex &other) {
        real += other.real;
        imag += other.imag;
        return *this;
    }
    
    // 重载前置++运算符
    Complex& operator++() {
        ++real;
        return *this;
    }
    
    // 重载后置++运算符
    Complex operator++(int) {
        Complex temp = *this;
        ++real;
        return temp;
    }
    
    // 重载输出运算符<<（友元函数）
    friend std::ostream& operator<<(std::ostream &os, const Complex &c);
    
    // 重载输入运算符>>（友元函数）
    friend std::istream& operator>>(std::istream &is, Complex &c);
};

// 重载<<运算符
std::ostream& operator<<(std::ostream &os, const Complex &c) {
    os << c.real;
    if (c.imag >= 0) {
        os << " + " << c.imag << "i";
    } else {
        os << " - " << -c.imag << "i";
    }
    return os;
}

// 重载>>运算符
std::istream& operator>>(std::istream &is, Complex &c) {
    is >> c.real >> c.imag;
    return is;
}</code></pre>
                </div>
            </section>

            <section id="templates" class="section">
                <h2>模板与泛型</h2>
                <p>模板是C++中实现泛型编程的工具，允许编写与数据类型无关的代码。</p>

                <h3>函数模板</h3>
                <div class="code-block">
                    <pre><code>// 函数模板
template <typename T>
T getMax(T a, T b) {
    return (a > b) ? a : b;
}

// 多类型参数的函数模板
template <typename T, typename U>
auto getMax(T a, U b) -> decltype(a > b ? a : b) {
    return (a > b) ? a : b;
}

// 特化版本
template <>
const char* getMax<const char*>(const char* a, const char* b) {
    return (strcmp(a, b) > 0) ? a : b;
}

// 可变参数模板 (C++11)
template <typename... Args>
void printAll(Args... args) {
    (std::cout << ... << args) << std::endl;  // 折叠表达式 (C++17)
}</code></pre>
                </div>

                <h3>类模板</h3>
                <div class="code-block">
                    <pre><code>// 类模板
template <typename T>
class Stack {
private:
    T* elements;
    int capacity;
    int topIndex;

public:
    Stack(int size = 10) : capacity(size), topIndex(-1) {
        elements = new T[capacity];
    }
    
    ~Stack() {
        delete[] elements;
    }
    
    void push(const T &value) {
        if (topIndex >= capacity - 1) {
            // 动态扩容
            capacity *= 2;
            T* newElements = new T[capacity];
            for (int i = 0; i <= topIndex; i++) {
                newElements[i] = elements[i];
            }
            delete[] elements;
            elements = newElements;
        }
        elements[++topIndex] = value;
    }
    
    T pop() {
        if (topIndex < 0) {
            throw std::out_of_range("栈为空");
        }
        return elements[topIndex--];
    }
    
    bool isEmpty() const {
        return topIndex == -1;
    }
    
    int size() const {
        return topIndex + 1;
    }
};</code></pre>
                </div>
            </section>

            <section id="best-practices" class="section">
                <h2>面向对象编程最佳实践</h2>

                <h3>设计原则</h3>
                <ol>
                    <li><strong>单一职责原则</strong>：一个类应该只有一个引起变化的原因</li>
                    <li><strong>开放封闭原则</strong>：对扩展开放，对修改关闭</li>
                    <li><strong>里氏替换原则</strong>：派生类必须能够替换其基类</li>
                    <li><strong>接口隔离原则</strong>：使用多个专门的接口，而不是一个庞大的接口</li>
                    <li><strong>依赖倒置原则</strong>：依赖于抽象而不是具体实现</li>
                </ol>

                <h3>C++特定建议</h3>
                <ul>
                    <li>优先使用组合而不是继承</li>
                    <li>使用const正确性</li>
                    <li>遵循Rule of Zero/Five</li>
                    <li>使用智能指针管理资源</li>
                    <li>避免过度使用继承，优先使用模板实现泛型</li>
                    <li>使用override和final关键字明确意图</li>
                    <li>谨慎使用友元，它破坏了封装性</li>
                </ul>

                <div class="advanced">
                    <h4>现代C++中的OOP</h4>
                    <p>现代C++开发中，OOP不再是唯一的编程范式。通常结合：</p>
                    <ul>
                        <li><strong>泛型编程</strong>：通过模板实现</li>
                        <li><strong>函数式编程</strong>：Lambda表达式、函数对象</li>
                        <li><strong>过程式编程</strong>：自由函数、算法</li>
                        <li><strong>元编程</strong>：编译时计算和代码生成</li>
                    </ul>
                    <p>选择合适的范式或组合多种范式，而不是强制使用纯粹的OOP。</p>
                </div>
            </section>

            <div class="navigation-buttons">
                <a href="basics.html" class="nav-button">上一章：C++基础</a>
                <a href="advanced.html" class="nav-button">下一章：高级特性</a>
            </div>
        </div>
    </main>

    <footer>
        <p>&copy; 2025 C++学习入门网站. 保留所有权利.</p>
    </footer>

    <!-- <script>
        // 移动端菜单切换
        document.querySelector('.burger').addEventListener('click', function () {
            document.querySelector('.nav-links').classList.toggle('active');
        });

        // 平滑滚动到锚点
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();

                const targetId = this.getAttribute('href');
                if (targetId === '#') return;

                const targetElement = document.querySelector(targetId);
                if (targetElement) {
                    targetElement.scrollIntoView({
                        behavior: 'smooth'
                    });

                    // 如果是移动端，点击后关闭菜单
                    if (window.innerWidth <= 900) {
                        document.querySelector('.nav-links').classList.remove('active');
                    }
                }
            });
        });
    </script> -->
    <!-- 改全局 -->
    <!-- 登录模态框 -->
    <div id="login-modal" class="modal">
        <div class="modal-content">
            <span class="close-button">&times;</span>
            <h2>用户登录</h2>
            <form id="login-form">
                <div class="form-group">
                    <label for="login-username">用户名</label>
                    <input type="text" id="login-username" placeholder="请输入用户名" required>
                </div>
                <div class="form-group">
                    <label for="login-password">密码</label>
                    <input type="password" id="login-password" placeholder="请输入密码" required>
                </div>
                <div class="form-options">
                    <label class="checkbox-label">
                        <input type="checkbox"> 记住我
                    </label>
                    <a href="#forgot-password-modal" class="forgot-password">忘记密码?</a>
                </div>
                <button type="submit" class="modal-btn">登录</button>
                <p class="register-link">还没有账号? <a href="#register-modal">立即注册</a></p>
            </form>
        </div>
    </div>

    <!-- 注册模态框 -->
    <div id="register-modal" class="modal">
        <div class="modal-content">
            <span class="close-button">&times;</span>
            <h2>用户注册</h2>
            <form id="register-form">
                <div class="form-group">
                    <label for="register-username">用户名</label>
                    <input type="text" id="register-username" placeholder="请设置用户名" required>
                </div>
                <div class="form-group">
                    <label for="register-email">邮箱</label>
                    <input type="email" id="register-email" placeholder="请输入邮箱" required>
                </div>
                <div class="form-group">
                    <label for="register-password">密码</label>
                    <input type="password" id="register-password" placeholder="请设置密码" required>
                </div>
                <div class="form-group">
                    <label for="register-confirm-password">确认密码</label>
                    <input type="password" id="register-confirm-password" placeholder="请再次输入密码" required>
                </div>
                <div class="form-options">
                    <label class="checkbox-label">
                        <input type="checkbox" id="agree-terms" name="agree-terms" required> 我已阅读并同意<a href="#" class="terms-link">用户协议</a>和<a href="#" class="privacy-link">隐私政策</a>
                    </label>
                </div>
                <button type="submit" class="modal-btn">注册</button>
                <p class="login-link">已有账号? <a href="#login-modal">立即登录</a></p>
            </form>
        </div>
    </div>

    <!-- 忘记密码模态框 -->
    <div id="forgot-password-modal" class="modal">
        <div class="modal-content">
            <span class="close-button">&times;</span>
            <h2>重置密码</h2>
            <form id="forgot-password-form">
                <div class="form-group">
                    <label for="forgot-email">邮箱</label>
                    <input type="email" id="forgot-email" placeholder="请输入注册邮箱" required>
                </div>
                <div class="form-group">
                    <label for="forgot-new-password">新密码</label>
                    <input type="password" id="forgot-new-password" placeholder="请输入新密码" required>
                </div>
                <div class="form-group">
                    <label for="forgot-confirm-password">确认新密码</label>
                    <input type="password" id="forgot-confirm-password" placeholder="请确认新密码" required>
                </div>
                <button type="submit" class="modal-btn">重置密码</button>
                <p class="login-link">想起密码了? <a href="#login-modal">立即登录</a></p>
            </form>
        </div>
    </div>

    <!-- 用户协议模态框 -->
    <div id="terms-modal" class="modal">
        <div class="modal-content">
            <span class="close-button">&times;</span>
            <h2>用户协议</h2>
            <div class="modal-text">
                                <h3>第一条 协议概述</h3>
                <p>欢迎使用C++学习入门网站（以下简称"本网站"）。本协议是您（以下简称"用户"）与本网站之间关于使用本网站服务的法律协议。请在使用本网站前仔细阅读本协议，一旦您开始使用本网站，即表示您同意接受本协议的全部条款。</p>
                
                <h3>第二条 服务内容</h3>
                <p>本网站致力于为用户提供优质的C++编程学习服务，主要包括但不限于：</p>
                <ul>
                    <li>C++基础语法、面向对象、高级特性等教学内容</li>
                    <li>在线测验题库和学习评估系统</li>
                    <li>用户学习进度跟踪和成就系统</li>
                    <li>学习论坛和用户交流平台</li>
                    <li>AI智能助手服务</li>
                    <li>其他与C++学习相关的辅助功能</li>
                </ul>
                
                <h3>第三条 用户注册与账户管理</h3>
                <ol>
                    <li><strong>注册要求</strong>：用户需要提供真实有效的邮箱地址和用户名进行注册</li>
                    <li><strong>账户安全</strong>：用户有责任保护自己的账户密码安全，不得将账户借给他人使用</li>
                    <li><strong>信息准确性</strong>：用户应确保注册信息的真实性和准确性</li>
                    <li><strong>账户停用</strong>：如发现用户提供虚假信息或违反本协议，网站有权停用相关账户</li>
                </ol>
                
                <h3>第四条 用户行为规范</h3>
                <p>用户在使用本网站时，应当遵守以下规范：</p>
                <p><strong>允许的行为：</strong></p>
                <ul>
                    <li>正常学习C++编程知识</li>
                    <li>在论坛中进行友善的学术讨论</li>
                    <li>分享学习心得和编程经验</li>
                    <li>合理使用AI助手进行学习辅导</li>
                </ul>
                <p><strong>禁止的行为：</strong></p>
                <ul>
                    <li>发布违法、有害、威胁、侮辱、诽谤的内容</li>
                    <li>发布与C++学习无关的广告或垃圾信息</li>
                    <li>恶意攻击网站系统或其他用户</li>
                    <li>传播病毒、恶意代码或有害程序</li>
                    <li>侵犯他人知识产权或隐私权</li>
                    <li>利用技术手段绕过网站的限制措施</li>
                </ul>
                
                <h3>第五条 知识产权</h3>
                <ol>
                    <li><strong>网站内容版权</strong>：本网站提供的所有教学内容、代码示例、题库等均受版权保护</li>
                    <li><strong>用户生成内容</strong>：用户在论坛发表的原创内容，版权归用户所有，但用户授予本网站使用权</li>
                    <li><strong>合理使用</strong>：用户可以将学习内容用于个人学习目的，但不得用于商业用途</li>
                    <li><strong>侵权处理</strong>：如发现侵权行为，请及时联系我们处理</li>
                </ol>
                
                <h3>第六条 AI助手服务条款</h3>
                <ol>
                    <li><strong>服务性质</strong>：AI助手仅作为学习辅助工具，提供编程相关的答疑和指导</li>
                    <li><strong>服务限制</strong>：AI助手的回答仅供参考，不保证绝对准确性</li>
                    <li><strong>使用规范</strong>：禁止利用AI助手进行违法、有害或与学习无关的活动</li>
                    <li><strong>数据使用</strong>：与AI助手的对话可能被记录用于改进服务质量</li>
                </ol>
                
                <h3>第七条 免责声明</h3>
                <ol>
                    <li><strong>服务可用性</strong>：网站不保证服务的不间断性和完全准确性</li>
                    <li><strong>第三方链接</strong>：对于第三方网站的内容，本网站不承担责任</li>
                    <li><strong>用户损失</strong>：因不可抗力或技术故障导致的用户损失，网站不承担责任</li>
                    <li><strong>内容责任</strong>：用户对其发布的内容承担全部法律责任</li>
                </ol>
                
                <h3>第八条 协议修改与终止</h3>
                <ol>
                    <li><strong>修改权利</strong>：本网站保留随时修改本协议的权利，修改后的协议将在网站上公布</li>
                    <li><strong>终止条件</strong>：如用户违反本协议，网站有权终止提供服务</li>
                    <li><strong>协议效力</strong>：本协议的终止不影响双方在终止前产生的权利义务</li>
                </ol>
                
                <h3>第九条 争议解决</h3>
                <p>本协议的解释和执行均适用中华人民共和国法律。如发生争议，双方应友好协商解决；协商不成的，可向网站所在地人民法院提起诉讼。</p>
                
                <h3>第十条 联系方式</h3>
                <p>如对本协议有任何疑问，请通过以下方式与我们联系：</p>
                <ul>
                    <li>邮箱：Hsy@bit.edu.cn</li>
                    <li>地址：北京理工大学良乡校区</li>
                </ul>
                
                <p><strong>生效日期</strong>：本协议自2025年9月14日起生效。
            </div>
            <button class="modal-btn" onclick="closeModal('terms-modal'); showModal('register-modal')">返回</button>
        </div>
    </div>

    <!-- 隐私政策模态框 -->
    <div id="privacy-modal" class="modal">
        <div class="modal-content">
            <span class="close-button">&times;</span>
            <h2>隐私政策</h2>
            <div class="modal-text">
                                <h3>第一条 隐私政策概述</h3>
                <p>本隐私政策说明C++学习入门网站（以下简称"我们"或"本网站"）如何收集、使用、存储和保护您的个人信息。我们承诺保护您的隐私安全，请仔细阅读本政策。</p>
                
                <h3>第二条 信息收集</h3>
                <p>我们收集的信息类型包括：</p>
                
                <h4>1. 注册信息</h4>
                <ul>
                    <li>用户名</li>
                    <li>邮箱地址</li>
                    <li>密码（经过加密处理）</li>
                </ul>
                
                <h4>2. 学习数据</h4>
                <ul>
                    <li>学习进度和章节完成情况</li>
                    <li>测验成绩和答题记录</li>
                    <li>学习时长和访问频率</li>
                    <li>成就获得记录</li>
                </ul>
                
                <h4>3. 交互数据</h4>
                <ul>
                    <li>论坛发帖和回复内容</li>
                    <li>与AI助手的对话记录</li>
                    <li>用户反馈和建议</li>
                </ul>
                
                <h4>4. 技术信息</h4>
                <ul>
                    <li>IP地址和设备信息</li>
                    <li>浏览器类型和版本</li>
                    <li>操作系统信息</li>
                    <li>访问时间和页面浏览记录</li>
                </ul>
                
                <h3>第三条 信息使用目的</h3>
                <p>我们收集和使用您的个人信息主要用于以下目的：</p>
                
                <h4>1. 服务提供</h4>
                <ul>
                    <li>创建和管理用户账户</li>
                    <li>提供个性化学习内容</li>
                    <li>跟踪学习进度和成就</li>
                    <li>提供AI助手服务</li>
                </ul>
                
                <h4>2. 沟通联系</h4>
                <ul>
                    <li>发送重要通知和更新</li>
                    <li>回应用户询问和反馈</li>
                    <li>发送学习提醒和激励信息</li>
                </ul>
                
                <h4>3. 服务改进</h4>
                <ul>
                    <li>分析用户学习行为和偏好</li>
                    <li>优化网站功能和用户体验</li>
                    <li>开发新的学习功能</li>
                </ul>
                
                <h4>4. 安全保障</h4>
                <ul>
                    <li>防止欺诈和滥用行为</li>
                    <li>维护网站和用户安全</li>
                    <li>遵守法律法规要求</li>
                </ul>
                
                <h3>第四条 信息共享与披露</h3>
                <p>我们承诺不会出售您的个人信息，但在以下情况下可能共享信息：</p>
                
                <h4>1. 第三方服务商</h4>
                <ul>
                    <li>AI服务提供商（用于AI助手功能）</li>
                    <li>邮件服务提供商（用于发送验证邮件）</li>
                    <li>云存储服务商（用于数据备份）</li>
                </ul>
                
                <h4>2. 法律要求</h4>
                <ul>
                    <li>遵守适用法律法规的要求</li>
                    <li>响应政府部门的合法请求</li>
                    <li>保护我们或他人的合法权益</li>
                </ul>
                
                <h4>3. 业务转让</h4>
                <ul>
                    <li>在合并、收购或资产转让时，经用户同意后转让相关信息</li>
                </ul>
                
                <h3>第五条 数据存储与安全</h3>
                
                <h4>1. 存储方式</h4>
                <ul>
                    <li>用户数据主要存储在用户本地浏览器中</li>
                    <li>部分数据存储在安全的服务器环境中</li>
                    <li>采用加密技术保护敏感信息</li>
                </ul>
                
                <h4>2. 安全措施</h4>
                <ul>
                    <li>使用HTTPS协议保护数据传输</li>
                    <li>对密码进行加密存储</li>
                    <li>定期进行安全审计和漏洞修复</li>
                </ul>
                
                <h4>3. 数据保留</h4>
                <ul>
                    <li>账户信息在账户存续期间保留</li>
                    <li>学习数据保留期限不超过法律要求的期限</li>
                    <li>用户可以要求删除特定数据</li>
                </ul>
                
                <h3>第六条 用户权利</h3>
                <p>您对自己的个人信息享有以下权利：</p>
                <ol>
                    <li><strong>访问权</strong>：查看我们持有的您的个人信息</li>
                    <li><strong>更正权</strong>：更正不准确或不完整的个人信息</li>
                    <li><strong>删除权</strong>：在特定情况下要求删除您的个人信息</li>
                    <li><strong>限制处理权</strong>：限制我们处理您的个人信息</li>
                    <li><strong>数据携带权</strong>：以结构化格式获取您的数据副本</li>
                    <li><strong>撤回同意权</strong>：随时撤回对特定数据处理的同意</li>
                </ol>
                
                <h3>第七条 Cookie和跟踪技术</h3>
                
                <h4>1. Cookie使用</h4>
                <ul>
                    <li>用于保持登录状态和用户偏好</li>
                    <li>分析网站使用情况和性能</li>
                    <li>您可以通过浏览器设置控制Cookie</li>
                </ul>
                
                <h4>2. 本地存储</h4>
                <ul>
                    <li>使用localStorage存储学习进度</li>
                    <li>存储用户界面偏好设置</li>
                    <li>缓存常用数据以提升性能</li>
                </ul>
                
                <h3>第八条 儿童隐私保护</h3>
                <p>我们不会故意收集13岁以下儿童的个人信息。如果我们发现收集了儿童的个人信息，将立即删除相关信息。如果您是儿童的家长或监护人，发现儿童提供了个人信息，请联系我们。</p>
                
                <h3>第九条 国际数据传输</h3>
                <p>如果您的数据需要跨境传输，我们将采取适当的保护措施，确保数据安全，并遵守相关法律法规的要求。</p>
                
                <h3>第十条 政策更新</h3>
                <p>我们可能会不定期更新本隐私政策。重大变更时，我们会通过网站公告或邮件通知的方式告知您。继续使用我们的服务即表示您接受更新后的政策。</p>
                
                <h3>第十一条 联系我们</h3>
                <p>如果您对本隐私政策有任何疑问、意见或投诉，或希望行使您的个人信息权利，请通过以下方式联系我们：</p>
                <ul>
                    <li>邮箱：Hsy@bit.edu.cn</li>
                    <li>地址：北京理工大学良乡校区</li>
                </ul>
                <p>我们将在收到您的请求后30个工作日内给予回复。</p>
                
                <p><strong>生效日期</strong>：本隐私政策自2025年9月14日起生效。
            </div>
            <button class="modal-btn" onclick="closeModal('privacy-modal'); showModal('register-modal')">返回</button>
        </div>
    </div>

    <!-- 提示消息 -->
    <div id="toast-message" class="toast"></div>

    <!-- 数据存储管理 -->
    <script src="../js/data-storage.js"></script>
    <!-- 主脚本 -->
    <script src="../js/main2.js"></script>
    <script src="../js/ai-assistant.js"></script>
    <!-- 全局数据管理功能 -->
    <script src="../js/data-management-ui.js"></script>
</body>

</html>